
//源码编译安装nodejs 会生成 node可执行程序（里面包含了nodejs的源码）
//+ node_modules(自带npm模块--用于安装管理其他模块)



var index = 1;

if(index==1)
{
//1、创建第一个应用
var http = require('http');

http.createServer(function (request, response) {

	// 发送 HTTP 头部 
	// HTTP 状态值: 200 : OK
	// 内容类型: text/plain
	response.writeHead(200, {'Content-Type': 'text/plain'});

	// 发送响应数据 "Hello World"
	response.end('Hello World\n');
}).listen(8888);

// 终端打印如下信息
console.log('Server running at http://127.0.0.1:8888/');
}
else if(index==2)
{
//2、npm 安装扩展 npm install express -g
var express = require('express');
}
else if(index==3)
{
//3、回调函数
var fs = require("fs");

var data = fs.readFileSync('input.txt'); //阻塞的
console.log(data.toString());
console.log("程序执行结束!");


fs.readFile('input.txt', function (err, data) { //非阻塞的
    if (err) return console.error(err);
    console.log(data.toString());
});
console.log("程序执行结束!");
}
else if(index==4)
{
//事件循环 
//Node.js 使用事件驱动模型，当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。
//当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。
//这个模型非常\
//效可扩展性非常强，因为webserver一直接受请求而不等待任何读写操作。（这也被称之为非阻塞式IO或者事件驱动IO）
//在事件驱动模型中，会生成一个主循环来监听事件，当检测到事件时触发回调函数。
	
	// 引入 events 模块
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();

// 创建事件处理程序
var connectHandler = function connected() {
   console.log('连接成功。');
  
   // 触发 data_received 事件 
   eventEmitter.emit('data_received');
}

// 绑定 connection 事件处理程序
eventEmitter.on('connection', connectHandler);
 
// 使用匿名函数绑定 data_received 事件
eventEmitter.on('data_received', function(){
   console.log('数据接收成功。');
});

// 触发 connection 事件 
eventEmitter.emit('connection');

console.log("程序执行完毕。");

var EventEmitter = require('events').EventEmitter; 
var event = new EventEmitter(); 
event.on('some_event', function() { 
	console.log('some_event 事件触发'); 
}); 
setTimeout(function() { 
	event.emit('some_event'); 
}, 1000); 


var emitter = new events.EventEmitter(); 
emitter.on('someEvent', function(arg1, arg2) { 
	console.log('listener1', arg1, arg2); 
}); 
emitter.on('someEvent', function(arg1, arg2) { 
	console.log('listener2', arg1, arg2); 
}); 
emitter.emit('someEvent', 'arg1 参数', 'arg2 参数'); 

/*
addListener(event, listener)
为指定事件添加一个监听器到监听器数组的尾部。

on(event, listener)
为指定事件注册一个监听器，接受一个字符串 event 和一个回调函数。

once(event, listener)
为指定事件注册一个单次监听器，即 监听器最多只会触发一次，触发后立刻解除该监听器。


removeListener(event, listener)
移除指定事件的某个监听器，监听器 必须是该事件已经注册过的监听器。

removeAllListeners([event])
移除所有事件的所有监听器， 如果指定事件，则移除指定事件的所有监听器。

setMaxListeners(n)
默认情况下， EventEmitters 如果你添加的监听器超过 10 个就会输出警告信息。 setMaxListeners 函数用于提高监听器的默认限制的数量。

listeners(event)
返回指定事件的监听器数组。

emit(event, [arg1], [arg2], [...])
按参数的顺序执行每个监听器，如果事件有注册监听返回 true，否则返回 false。

listenerCount(emitter, event)
返回指定事件的监听器数量。
*/
}
else if(index==5)
{
//Buffer(缓冲区)
//在处理像TCP流或文件流时，必须使用到二进制数据。
//因此在 Node.js中，定义了一个 Buffer 类，该类用来创建一个专门存放二进制数据的缓存区。

//创建
buf = new Buffer(256);
len = buf.write("www.runoob.com");
console.log("写入字节数 : "+  len);


//读取
buf = new Buffer(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}
console.log( buf.toString('ascii'));       // 输出: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));   // 输出: abcde
console.log( buf.toString('utf8',0,5));    // 输出: abcde
console.log( buf.toString(undefined,0,5)); // 使用 'utf8' 编码, 并输出: abcde


//tojson
var buf = new Buffer('www.runoob.com');
var json = buf.toJSON(buf);
console.log(json);
//[ 119, 119, 119, 46, 114, 117, 110, 111, 111, 98, 46, 99, 111, 109 ]


//合并
var buffer1 = new Buffer('菜鸟教程 ');
var buffer2 = new Buffer('www.runoob.com');
var buffer3 = Buffer.concat([buffer1,buffer2]);
console.log("buffer3 内容: " + buffer3.toString());


/*
写入 Node 缓冲区的语法如下所示：
buf.write(string[, offset][, length][, encoding])
参数
参数描述如下：
string - 写入缓冲区的字符串。
offset - 缓冲区开始写入的索引值，默认为 0 。
length - 写入的字节数，默认为 buffer.length
encoding - 使用的编码。默认为 'utf8' 。
返回值
返回实际写入的大小。如果 buffer 空间不足， 则只会写入部分字符串。


读取
读取 Node 缓冲区数据的语法如下所示：
buf.toString([encoding][, start][, end])
参数
参数描述如下：
encoding - 使用的编码。默认为 'utf8' 。
start - 指定开始读取的索引位置，默认为 0。
end - 结束位置，默认为缓冲区的末尾。
返回值
解码缓冲区数据并使用指定的编码返回字符串。


合并
Node 缓冲区合并的语法如下所示：
Buffer.concat(list[, totalLength])
参数
参数描述如下：
list - 用于合并的 Buffer 对象数组列表。
totalLength - 指定合并后Buffer对象的总长度。
返回值
返回一个多个成员合并的新 Buffer 对象。


比较
Node Buffer 比较的函数语法如下所示：
buf.compare(otherBuffer);
参数
参数描述如下：
otherBuffer - 与 buf 对象比较的另外一个 Buffer 对象。
返回值
返回一个数字，表示 buf 在 otherBuffer 之前，之后或相同。


Node 缓冲区拷贝语法如下所示：
buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])


Node 缓冲区裁剪语法如下所示：
buf.slice([start][, end])

Node 缓冲区长度计算语法如下所示：
buf.length;
*/
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}
else if(index==4)
{
}





















